diff --git a/system/core/Benchmark.php b/system/core/Benchmark.php
index da246c9..f4dfd3d 100755
--- a/system/core/Benchmark.php
+++ b/system/core/Benchmark.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -15,7 +15,7 @@
  * If you did not receive a copy of the license and are unable to obtain it
  * through the world wide web, please send an email to
  * licensing@ellislab.com so we can send you a copy immediately.
- * 
+ *
  * @package		CodeIgniter
  * @author		EllisLab Dev Team
  * @copyright	Copyright (c) 2008 - 2012, EllisLab, Inc. (http://ellislab.com/)
@@ -46,7 +46,7 @@
 	 *
 	 * @var array
 	 */
-	var $marker = array();
+	public $marker = array();
 
 	// --------------------------------------------------------------------
 
@@ -56,11 +56,10 @@
 	 * Multiple calls to this function can be made so that several
 	 * execution points can be timed
 	 *
-	 * @access	public
 	 * @param	string	$name	name of the marker
 	 * @return	void
 	 */
-	function mark($name)
+	public function mark($name)
 	{
 		$this->marker[$name] = microtime();
 	}
@@ -75,13 +74,12 @@
 	 * execution time to be shown in a template. The output class will
 	 * swap the real value for this variable.
 	 *
-	 * @access	public
 	 * @param	string	a particular marked point
 	 * @param	string	a particular marked point
 	 * @param	integer	the number of decimal places
 	 * @return	mixed
 	 */
-	function elapsed_time($point1 = '', $point2 = '', $decimals = 4)
+	public function elapsed_time($point1 = '', $point2 = '', $decimals = 4)
 	{
 		if ($point1 == '')
 		{
@@ -114,17 +112,14 @@
 	 * without the memory being calculated until the end.
 	 * The output class will swap the real value for this variable.
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function memory_usage()
+	public function memory_usage()
 	{
 		return '{memory_usage}';
 	}
 
 }
 
-// END CI_Benchmark class
-
 /* End of file Benchmark.php */
-/* Location: ./system/core/Benchmark.php */
\ No newline at end of file
+/* Location: ./system/core/Benchmark.php */
diff --git a/system/core/Hooks.php b/system/core/Hooks.php
index 174adcb..e1ac58e 100755
--- a/system/core/Hooks.php
+++ b/system/core/Hooks.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -45,28 +45,24 @@
 	 *
 	 * @var bool
 	 */
-	var $enabled		= FALSE;
+	public $enabled		= FALSE;
 	/**
 	 * List of all hooks set in config/hooks.php
 	 *
 	 * @var array
 	 */
-	var $hooks			= array();
+	public $hooks			= array();
 	/**
 	 * Determines wether hook is in progress, used to prevent infinte loops
 	 *
 	 * @var bool
 	 */
-	var $in_progress	= FALSE;
+	public $in_progress	= FALSE;
 
-	/**
-	 * Constructor
-	 *
-	 */
-	function __construct()
+	public function __construct()
 	{
 		$this->_initialize();
-		log_message('debug', "Hooks Class Initialized");
+		log_message('debug', 'Hooks Class Initialized');
 	}
 
 	// --------------------------------------------------------------------
@@ -74,24 +70,20 @@
 	/**
 	 * Initialize the Hooks Preferences
 	 *
-	 * @access	private
 	 * @return	void
 	 */
-	function _initialize()
+	private function _initialize()
 	{
 		$CFG =& load_class('Config', 'core');
 
 		// If hooks are not enabled in the config file
 		// there is nothing else to do
-
 		if ($CFG->item('enable_hooks') == FALSE)
 		{
 			return;
 		}
 
 		// Grab the "hooks" definition file.
-		// If there are no hooks, we're done.
-
 		if (defined('ENVIRONMENT') AND is_file(APPPATH.'config/'.ENVIRONMENT.'/hooks.php'))
 		{
 			include(APPPATH.'config/'.ENVIRONMENT.'/hooks.php');
@@ -101,7 +93,7 @@
 			include(APPPATH.'config/hooks.php');
 		}
 
-
+		// If there are no hooks, we're done.
 		if ( ! isset($hook) OR ! is_array($hook))
 		{
 			return;
@@ -116,13 +108,12 @@
 	/**
 	 * Call Hook
 	 *
-	 * Calls a particular hook
+	 * Calls a particular hook. Called by CodeIgniter.php.
 	 *
-	 * @access	private
 	 * @param	string	the hook name
 	 * @return	mixed
 	 */
-	function _call_hook($which = '')
+	public function _call_hook($which = '')
 	{
 		if ( ! $this->enabled OR ! isset($this->hooks[$which]))
 		{
@@ -151,11 +142,10 @@
 	 *
 	 * Runs a particular hook
 	 *
-	 * @access	private
 	 * @param	array	the hook details
 	 * @return	bool
 	 */
-	function _run_hook($data)
+	protected function _run_hook($data)
 	{
 		if ( ! is_array($data))
 		{
@@ -168,7 +158,6 @@
 
 		// If the script being called happens to have the same
 		// hook call within it a loop can happen
-
 		if ($this->in_progress == TRUE)
 		{
 			return;
@@ -254,7 +243,5 @@
 
 }
 
-// END CI_Hooks class
-
 /* End of file Hooks.php */
-/* Location: ./system/core/Hooks.php */
\ No newline at end of file
+/* Location: ./system/core/Hooks.php */
diff --git a/system/core/Lang.php b/system/core/Lang.php
index 5eb2801..088cb6c 100755
--- a/system/core/Lang.php
+++ b/system/core/Lang.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -43,22 +43,17 @@
 	 *
 	 * @var array
 	 */
-	var $language	= array();
+	public $language	= array();
 	/**
 	 * List of loaded language files
 	 *
 	 * @var array
 	 */
-	var $is_loaded	= array();
+	public $is_loaded	= array();
 
-	/**
-	 * Constructor
-	 *
-	 * @access	public
-	 */
-	function __construct()
+	public function __construct()
 	{
-		log_message('debug', "Language Class Initialized");
+		log_message('debug', 'Language Class Initialized');
 	}
 
 	// --------------------------------------------------------------------
@@ -66,7 +61,6 @@
 	/**
 	 * Load a language file
 	 *
-	 * @access	public
 	 * @param	mixed	the name of the language file to be loaded. Can be an array
 	 * @param	string	the language (english, etc.)
 	 * @param	bool	return loaded array of translations
@@ -74,7 +68,7 @@
 	 * @param 	string	alternative path to look for language file
 	 * @return	mixed
 	 */
-	function load($langfile = '', $idiom = '', $return = FALSE, $add_suffix = TRUE, $alt_path = '')
+	public function load($langfile = '', $idiom = '', $return = FALSE, $add_suffix = TRUE, $alt_path = '')
 	{
 		$langfile = str_replace('.php', '', $langfile);
 
@@ -148,11 +142,10 @@
 	/**
 	 * Fetch a single line of text from the language array
 	 *
-	 * @access	public
 	 * @param	string	$line	the language line
 	 * @return	string
 	 */
-	function line($line = '')
+	public function line($line = '')
 	{
 		$value = ($line == '' OR ! isset($this->language[$line])) ? FALSE : $this->language[$line];
 
@@ -166,7 +159,6 @@
 	}
 
 }
-// END Language Class
 
 /* End of file Lang.php */
 /* Location: ./system/core/Lang.php */
diff --git a/system/core/Loader.php b/system/core/Loader.php
index c4a6b50..272fe42 100644
--- a/system/core/Loader.php
+++ b/system/core/Loader.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -45,88 +45,77 @@
 	 * Nesting level of the output buffering mechanism
 	 *
 	 * @var int
-	 * @access protected
 	 */
 	protected $_ci_ob_level;
 	/**
 	 * List of paths to load views from
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_view_paths		= array();
 	/**
 	 * List of paths to load libraries from
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_library_paths	= array();
 	/**
 	 * List of paths to load models from
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_model_paths		= array();
 	/**
 	 * List of paths to load helpers from
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_helper_paths		= array();
 	/**
 	 * List of loaded base classes
-	 * Set by the controller class
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_base_classes		= array(); // Set by the controller class
 	/**
 	 * List of cached variables
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_cached_vars		= array();
 	/**
 	 * List of loaded classes
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_classes			= array();
 	/**
 	 * List of loaded files
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_loaded_files		= array();
 	/**
 	 * List of loaded models
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_models			= array();
 	/**
 	 * List of loaded helpers
 	 *
 	 * @var array
-	 * @access protected
 	 */
 	protected $_ci_helpers			= array();
 	/**
 	 * List of class name mappings
 	 *
 	 * @var array
-	 * @access protected
 	 */
-	protected $_ci_varmap			= array('unit_test' => 'unit',
-											'user_agent' => 'agent');
+	protected $_ci_varmap			= array(
+							'unit_test' => 'unit',
+							'user_agent' => 'agent'
+							);
 
 	/**
 	 * Constructor
@@ -141,7 +130,7 @@
 		$this->_ci_model_paths = array(APPPATH);
 		$this->_ci_view_paths = array(VIEWPATH	=> TRUE);
 
-		log_message('debug', "Loader Class Initialized");
+		log_message('debug', 'Loader Class Initialized');
 	}
 
 	// --------------------------------------------------------------------
@@ -162,7 +151,6 @@
 		$this->_base_classes =& is_loaded();
 
 		$this->_ci_autoloader();
-
 		return $this;
 	}
 
@@ -311,9 +299,7 @@
 			require_once($mod_path.'models/'.$path.$model.'.php');
 
 			$model = ucfirst($model);
-
 			$CI->$name = new $model();
-
 			$this->_ci_models[] = $name;
 			return;
 		}
@@ -350,7 +336,7 @@
 			return DB($params, $active_record);
 		}
 
-		// Initialize the db variable.  Needed to prevent
+		// Initialize the db variable. Needed to prevent
 		// reference errors with some configurations
 		$CI->db = '';
 
@@ -716,11 +702,11 @@
 
 		if ($path == '')
 		{
-			$void = array_shift($this->_ci_library_paths);
-			$void = array_shift($this->_ci_model_paths);
-			$void = array_shift($this->_ci_helper_paths);
-			$void = array_shift($this->_ci_view_paths);
-			$void = array_shift($config->_config_paths);
+			array_shift($this->_ci_library_paths);
+			array_shift($this->_ci_model_paths);
+			array_shift($this->_ci_helper_paths);
+			array_shift($this->_ci_view_paths);
+			array_shift($config->_config_paths);
 		}
 		else
 		{
@@ -808,7 +794,6 @@
 
 		// This allows anything loaded using $this->load (views, files, etc.)
 		// to become accessible from within the Controller and Model functions.
-
 		$_ci_CI =& get_instance();
 		foreach (get_object_vars($_ci_CI) as $_ci_key => $_ci_var)
 		{
@@ -837,12 +822,11 @@
 		 *
 		 * We buffer the output for two reasons:
 		 * 1. Speed. You get a significant speed boost.
-		 * 2. So that the final rendered template can be
-		 * post-processed by the output class.  Why do we
-		 * need post processing?  For one thing, in order to
-		 * show the elapsed page load time.  Unless we
-		 * can intercept the content right before it's sent to
-		 * the browser and then stop the timer it won't be accurate.
+		 * 2. So that the final rendered template can be post-processed by
+		 *    the output class. Why do we need post processing? For one thing,
+		 *    in order to show the elapsed page load time. Unless we can
+		 *    intercept the content right before it's sent to the browser and
+		 *    then stop the timer it won't be accurate.
 		 */
 		ob_start();
 
@@ -915,10 +899,10 @@
 		if (($last_slash = strrpos($class, '/')) !== FALSE)
 		{
 			// Extract the path
-			$subdir = substr($class, 0, $last_slash + 1);
+			$subdir = substr($class, 0, ++$last_slash);
 
 			// Get the filename from the path
-			$class = substr($class, $last_slash + 1);
+			$class = substr($class, $last_slash);
 		}
 
 		// We'll test for both lowercase and capitalized versions of the file name
@@ -933,15 +917,15 @@
 
 				if ( ! file_exists($baseclass))
 				{
-					log_message('error', "Unable to load the requested class: ".$class);
-					show_error("Unable to load the requested class: ".$class);
+					log_message('error', 'Unable to load the requested class: '.$class);
+					show_error('Unable to load the requested class: '.$class);
 				}
 
-				// Safety:  Was the class already loaded by a previous call?
+				// Safety: Was the class already loaded by a previous call?
 				if (in_array($subclass, $this->_ci_loaded_files))
 				{
 					// Before we deem this to be a duplicate request, let's see
-					// if a custom object name is being supplied.  If so, we'll
+					// if a custom object name is being supplied. If so, we'll
 					// return a new instance of the object
 					if ( ! is_null($object_name))
 					{
@@ -953,7 +937,7 @@
 					}
 
 					$is_duplicate = TRUE;
-					log_message('debug', $class." class already loaded. Second attempt ignored.");
+					log_message('debug', $class.' class already loaded. Second attempt ignored.');
 					return;
 				}
 
@@ -970,17 +954,17 @@
 			{
 				$filepath = $path.'libraries/'.$subdir.$class.'.php';
 
-				// Does the file exist?  No?  Bummer...
+				// Does the file exist? No? Bummer...
 				if ( ! file_exists($filepath))
 				{
 					continue;
 				}
 
-				// Safety:  Was the class already loaded by a previous call?
+				// Safety: Was the class already loaded by a previous call?
 				if (in_array($filepath, $this->_ci_loaded_files))
 				{
 					// Before we deem this to be a duplicate request, let's see
-					// if a custom object name is being supplied.  If so, we'll
+					// if a custom object name is being supplied. If so, we'll
 					// return a new instance of the object
 					if ( ! is_null($object_name))
 					{
@@ -992,7 +976,7 @@
 					}
 
 					$is_duplicate = TRUE;
-					log_message('debug', $class." class already loaded. Second attempt ignored.");
+					log_message('debug', $class.' class already loaded. Second attempt ignored.');
 					return;
 				}
 
@@ -1003,7 +987,7 @@
 
 		} // END FOREACH
 
-		// One last attempt.  Maybe the library is in a subdirectory, but it wasn't specified?
+		// One last attempt. Maybe the library is in a subdirectory, but it wasn't specified?
 		if ($subdir == '')
 		{
 			$path = strtolower($class).'/'.$class;
@@ -1014,8 +998,8 @@
 		// We do not issue errors if the load call failed due to a duplicate request
 		if ($is_duplicate == FALSE)
 		{
-			log_message('error', "Unable to load the requested class: ".$class);
-			show_error("Unable to load the requested class: ".$class);
+			log_message('error', 'Unable to load the requested class: '.$class);
+			show_error('Unable to load the requested class: '.$class);
 		}
 	}
 
@@ -1094,12 +1078,12 @@
 		// Is the class name valid?
 		if ( ! class_exists($name))
 		{
-			log_message('error', "Non-existent class: ".$name);
-			show_error("Non-existent class: ".$class);
+			log_message('error', 'Non-existent class: '.$name);
+			show_error('Non-existent class: '.$class);
 		}
 
 		// Set the variable name we will assign the class to
-		// Was a custom class name supplied?  If so we'll use it
+		// Was a custom class name supplied? If so we'll use it
 		$class = strtolower($class);
 
 		if (is_null($object_name))
@@ -1181,13 +1165,6 @@
 			}
 		}
 
-		// A little tweak to remain backward compatible
-		// The $autoload['core'] item was deprecated
-		if ( ! isset($autoload['libraries']) AND isset($autoload['core']))
-		{
-			$autoload['libraries'] = $autoload['core'];
-		}
-
 		// Load libraries
 		if (isset($autoload['libraries']) AND count($autoload['libraries']) > 0)
 		{
@@ -1271,4 +1248,4 @@
 }
 
 /* End of file Loader.php */
-/* Location: ./system/core/Loader.php */
\ No newline at end of file
+/* Location: ./system/core/Loader.php */
diff --git a/system/core/Router.php b/system/core/Router.php
index 8cad868..d213195 100755
--- a/system/core/Router.php
+++ b/system/core/Router.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -44,62 +44,55 @@
 	 * Config class
 	 *
 	 * @var object
-	 * @access public
 	 */
-	var $config;
+	public $config;
 	/**
 	 * List of routes
 	 *
 	 * @var array
-	 * @access public
 	 */
-	var $routes			= array();
+	public $routes			= array();
 	/**
 	 * List of error routes
 	 *
 	 * @var array
-	 * @access public
 	 */
-	var $error_routes	= array();
+	public $error_routes	= array();
 	/**
 	 * Current class name
 	 *
 	 * @var string
-	 * @access public
 	 */
-	var $class			= '';
+	public $class			= '';
 	/**
 	 * Current method name
 	 *
 	 * @var string
-	 * @access public
 	 */
-	var $method			= 'index';
+	public $method			= 'index';
 	/**
 	 * Sub-directory that contains the requested controller class
 	 *
 	 * @var string
-	 * @access public
 	 */
-	var $directory		= '';
+	public $directory		= '';
 	/**
 	 * Default controller (and method if specific)
 	 *
 	 * @var string
-	 * @access public
 	 */
-	var $default_controller;
+	public $default_controller;
 
 	/**
 	 * Constructor
 	 *
 	 * Runs the route mapping function.
 	 */
-	function __construct()
+	public function __construct()
 	{
 		$this->config =& load_class('Config', 'core');
 		$this->uri =& load_class('URI', 'core');
-		log_message('debug', "Router Class Initialized");
+		log_message('debug', 'Router Class Initialized');
 	}
 
 	// --------------------------------------------------------------------
@@ -110,12 +103,11 @@
 	 * This function determines what should be served based on the URI request,
 	 * as well as any "routes" that have been set in the routing config file.
 	 *
-	 * @access	private
 	 * @return	void
 	 */
-	function _set_routing()
+	public function _set_routing()
 	{
-		// Are query strings enabled in the config file?  Normally CI doesn't utilize query strings
+		// Are query strings enabled in the config file? Normally CI doesn't utilize query strings
 		// since URI segments are more search-engine friendly, but they can optionally be used.
 		// If this feature is enabled, we will gather the directory/class/method a little differently
 		$segments = array();
@@ -157,7 +149,7 @@
 		// the URI doesn't correlated to a valid controller.
 		$this->default_controller = ( ! isset($this->routes['default_controller']) OR $this->routes['default_controller'] == '') ? FALSE : strtolower($this->routes['default_controller']);
 
-		// Were there any query string segments?  If so, we'll validate them and bail out since we're done.
+		// Were there any query string segments? If so, we'll validate them and bail out since we're done.
 		if (count($segments) > 0)
 		{
 			return $this->_validate_request($segments);
@@ -172,17 +164,10 @@
 			return $this->_set_default_controller();
 		}
 
-		// Do we need to remove the URL suffix?
-		$this->uri->_remove_url_suffix();
-
-		// Compile the segments into an array
-		$this->uri->_explode_segments();
-
-		// Parse any custom routing that may exist
-		$this->_parse_routes();
-
-		// Re-index the segment array so that it starts with 1 rather than 0
-		$this->uri->_reindex_segments();
+		$this->uri->_remove_url_suffix(); // Remove the URL suffix
+		$this->uri->_explode_segments(); // Compile the segments into an array
+		$this->_parse_routes(); // Parse any custom routing that may exist
+		$this->uri->_reindex_segments(); // Re-index the segment array so that it starts with 1 rather than 0
 	}
 
 	// --------------------------------------------------------------------
@@ -190,20 +175,18 @@
 	/**
 	 * Set the default controller
 	 *
-	 * @access	private
 	 * @return	void
 	 */
-	function _set_default_controller()
+	protected function _set_default_controller()
 	{
 		if ($this->default_controller === FALSE)
 		{
-			show_error("Unable to determine what should be displayed. A default route has not been specified in the routing file.");
+			show_error('Unable to determine what should be displayed. A default route has not been specified in the routing file.');
 		}
 		// Is the method being specified?
 		if (strpos($this->default_controller, '/') !== FALSE)
 		{
 			$x = explode('/', $this->default_controller);
-
 			$this->set_class($x[0]);
 			$this->set_method($x[1]);
 			$this->_set_request($x);
@@ -218,7 +201,7 @@
 		// re-index the routed segments array so it starts with 1 rather than 0
 		$this->uri->_reindex_segments();
 
-		log_message('debug', "No URI present. Default controller set.");
+		log_message('debug', 'No URI present. Default controller set.');
 	}
 
 	// --------------------------------------------------------------------
@@ -229,16 +212,15 @@
 	 * This function takes an array of URI segments as
 	 * input, and sets the current class/method
 	 *
-	 * @access	private
 	 * @param	array
 	 * @param	bool
 	 * @return	void
 	 */
-	function _set_request($segments = array())
+	protected function _set_request($segments = array())
 	{
 		$segments = $this->_validate_request($segments);
 
-		if (count($segments) == 0)
+		if (count($segments) === 0)
 		{
 			return $this->_set_default_controller();
 		}
@@ -269,13 +251,12 @@
 	 * Validates the supplied segments.  Attempts to determine the path to
 	 * the controller.
 	 *
-	 * @access	private
 	 * @param	array
 	 * @return	array
 	 */
-	function _validate_request($segments)
+	protected function _validate_request($segments)
 	{
-		if (count($segments) == 0)
+		if (count($segments) === 0)
 		{
 			return $segments;
 		}
@@ -301,7 +282,6 @@
 					if ( ! empty($this->routes['404_override']))
 					{
 						$x = explode('/', $this->routes['404_override']);
-
 						$this->set_directory('');
 						$this->set_class($x[0]);
 						$this->set_method(isset($x[1]) ? $x[1] : 'index');
@@ -320,7 +300,6 @@
 				if (strpos($this->default_controller, '/') !== FALSE)
 				{
 					$x = explode('/', $this->default_controller);
-
 					$this->set_class($x[0]);
 					$this->set_method($x[1]);
 				}
@@ -344,18 +323,16 @@
 
 
 		// If we've gotten this far it means that the URI does not correlate to a valid
-		// controller class.  We will now see if there is an override
+		// controller class. We will now see if there is an override
 		if ( ! empty($this->routes['404_override']))
 		{
 			$x = explode('/', $this->routes['404_override']);
-
 			$this->set_class($x[0]);
 			$this->set_method(isset($x[1]) ? $x[1] : 'index');
 
 			return $x;
 		}
 
-
 		// Nothing else to do at this point but show a 404
 		show_404($segments[0]);
 	}
@@ -369,10 +346,9 @@
 	 * the config/routes.php file against the URI to
 	 * determine if the class/method need to be remapped.
 	 *
-	 * @access	private
 	 * @return	void
 	 */
-	function _parse_routes()
+	protected function _parse_routes()
 	{
 		// Turn the segment array into a URI string
 		$uri = implode('/', $this->uri->segments);
@@ -387,7 +363,7 @@
 		foreach ($this->routes as $key => $val)
 		{
 			// Convert wild-cards to RegEx
-			$key = str_replace(':any', '.+', str_replace(':num', '[0-9]+', $key));
+			$key = str_replace(array(':any', ':num'), array('.+', '[0-9]+'), $key);
 
 			// Does the RegEx match?
 			if (preg_match('#^'.$key.'$#', $uri))
@@ -412,11 +388,10 @@
 	/**
 	 * Set the class name
 	 *
-	 * @access	public
 	 * @param	string
 	 * @return	void
 	 */
-	function set_class($class)
+	public function set_class($class)
 	{
 		$this->class = str_replace(array('/', '.'), '', $class);
 	}
@@ -426,10 +401,9 @@
 	/**
 	 * Fetch the current class
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function fetch_class()
+	public function fetch_class()
 	{
 		return $this->class;
 	}
@@ -439,11 +413,10 @@
 	/**
 	 *  Set the method name
 	 *
-	 * @access	public
 	 * @param	string
 	 * @return	void
 	 */
-	function set_method($method)
+	public function set_method($method)
 	{
 		$this->method = $method;
 	}
@@ -453,10 +426,9 @@
 	/**
 	 *  Fetch the current method
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function fetch_method()
+	public function fetch_method()
 	{
 		if ($this->method == $this->fetch_class())
 		{
@@ -471,11 +443,10 @@
 	/**
 	 *  Set the directory name
 	 *
-	 * @access	public
 	 * @param	string
 	 * @return	void
 	 */
-	function set_directory($dir)
+	public function set_directory($dir)
 	{
 		$this->directory = str_replace(array('/', '.'), '', $dir).'/';
 	}
@@ -485,10 +456,9 @@
 	/**
 	 *  Fetch the sub-directory (if any) that contains the requested controller class
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function fetch_directory()
+	public function fetch_directory()
 	{
 		return $this->directory;
 	}
@@ -498,11 +468,10 @@
 	/**
 	 *  Set the controller overrides
 	 *
-	 * @access	public
 	 * @param	array
 	 * @return	null
 	 */
-	function _set_overrides($routing)
+	public function _set_overrides($routing)
 	{
 		if ( ! is_array($routing))
 		{
@@ -526,9 +495,7 @@
 		}
 	}
 
-
 }
-// END Router Class
 
 /* End of file Router.php */
-/* Location: ./system/core/Router.php */
\ No newline at end of file
+/* Location: ./system/core/Router.php */
diff --git a/system/core/URI.php b/system/core/URI.php
index 3c26d30..eaf7b75 100755
--- a/system/core/URI.php
+++ b/system/core/URI.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -44,62 +44,56 @@
 	 * List of cached uri segments
 	 *
 	 * @var array
-	 * @access public
 	 */
-	var	$keyval			= array();
+	public $keyval		= array();
 	/**
 	 * Current uri string
 	 *
 	 * @var string
-	 * @access public
 	 */
-	var $uri_string;
+	public $uri_string;
 	/**
 	 * List of uri segments
 	 *
 	 * @var array
-	 * @access public
 	 */
-	var $segments		= array();
+	public $segments	= array();
 	/**
 	 * Re-indexed list of uri segments
 	 * Starts at 1 instead of 0
 	 *
 	 * @var array
-	 * @access public
 	 */
-	var $rsegments		= array();
+	public $rsegments	= array();
 
 	/**
 	 * Constructor
 	 *
-	 * Simply globalizes the $RTR object.  The front
+	 * Simply globalizes the $RTR object. The front
 	 * loads the Router class early on so it's not available
 	 * normally as other classes are.
-	 *
-	 * @access	public
 	 */
-	function __construct()
+	public function __construct()
 	{
 		$this->config =& load_class('Config', 'core');
-		log_message('debug', "URI Class Initialized");
+		log_message('debug', 'URI Class Initialized');
 	}
 
-
 	// --------------------------------------------------------------------
 
 	/**
 	 * Get the URI String
 	 *
-	 * @access	private
-	 * @return	string
+	 * Called by CI_Router
+	 *
+	 * @return	void
 	 */
-	function _fetch_uri_string()
+	public function _fetch_uri_string()
 	{
-		if (strtoupper($this->config->item('uri_protocol')) == 'AUTO')
+		if (strtoupper($this->config->item('uri_protocol')) === 'AUTO')
 		{
 			// Is the request coming from the command line?
-			if (php_sapi_name() == 'cli' or defined('STDIN'))
+			if (php_sapi_name() === 'cli' OR defined('STDIN'))
 			{
 				$this->_set_uri_string($this->_parse_cli_args());
 				return;
@@ -115,14 +109,14 @@
 			// Is there a PATH_INFO variable?
 			// Note: some servers seem to have trouble with getenv() so we'll test it two ways
 			$path = (isset($_SERVER['PATH_INFO'])) ? $_SERVER['PATH_INFO'] : @getenv('PATH_INFO');
-			if (trim($path, '/') != '' && $path != "/".SELF)
+			if (trim($path, '/') != '' && $path !== '/'.SELF)
 			{
 				$this->_set_uri_string($path);
 				return;
 			}
 
 			// No PATH_INFO?... What about QUERY_STRING?
-			$path =  (isset($_SERVER['QUERY_STRING'])) ? $_SERVER['QUERY_STRING'] : @getenv('QUERY_STRING');
+			$path = (isset($_SERVER['QUERY_STRING'])) ? $_SERVER['QUERY_STRING'] : @getenv('QUERY_STRING');
 			if (trim($path, '/') != '')
 			{
 				$this->_set_uri_string($path);
@@ -130,7 +124,7 @@
 			}
 
 			// As a last ditch effort lets try using the $_GET array
-			if (is_array($_GET) && count($_GET) == 1 && trim(key($_GET), '/') != '')
+			if (is_array($_GET) && count($_GET) === 1 && trim(key($_GET), '/') != '')
 			{
 				$this->_set_uri_string(key($_GET));
 				return;
@@ -143,12 +137,12 @@
 
 		$uri = strtoupper($this->config->item('uri_protocol'));
 
-		if ($uri == 'REQUEST_URI')
+		if ($uri === 'REQUEST_URI')
 		{
 			$this->_set_uri_string($this->_detect_uri());
 			return;
 		}
-		elseif ($uri == 'CLI')
+		elseif ($uri === 'CLI')
 		{
 			$this->_set_uri_string($this->_parse_cli_args());
 			return;
@@ -163,17 +157,16 @@
 	/**
 	 * Set the URI String
 	 *
-	 * @access	public
 	 * @param 	string
-	 * @return	string
+	 * @return	void
 	 */
-	function _set_uri_string($str)
+	public function _set_uri_string($str)
 	{
 		// Filter out control characters
 		$str = remove_invisible_characters($str, FALSE);
 
 		// If the URI contains only a slash we'll kill it
-		$this->uri_string = ($str == '/') ? '' : $str;
+		$this->uri_string = ($str === '/') ? '' : $str;
 	}
 
 	// --------------------------------------------------------------------
@@ -184,7 +177,6 @@
 	 * This function will detect the URI automatically and fix the query string
 	 * if necessary.
 	 *
-	 * @access	private
 	 * @return	string
 	 */
 	protected function _detect_uri()
@@ -194,12 +186,11 @@
 			return '';
 		}
 
-		$uri = $_SERVER['REQUEST_URI'];
-		if (strpos($uri, $_SERVER['SCRIPT_NAME']) === 0)
+		if (strpos($_SERVER['REQUEST_URI'], $_SERVER['SCRIPT_NAME']) === 0)
 		{
 			$uri = substr($uri, strlen($_SERVER['SCRIPT_NAME']));
 		}
-		elseif (strpos($uri, dirname($_SERVER['SCRIPT_NAME'])) === 0)
+		elseif (strpos($_SERVER['REQUEST_URI'], dirname($_SERVER['SCRIPT_NAME'])) === 0)
 		{
 			$uri = substr($uri, strlen(dirname($_SERVER['SCRIPT_NAME'])));
 		}
@@ -223,7 +214,7 @@
 			$_GET = array();
 		}
 
-		if ($uri == '/' || empty($uri))
+		if ($uri == '/' OR empty($uri))
 		{
 			return '/';
 		}
@@ -241,13 +232,11 @@
 	 *
 	 * Take each command line argument and assume it is a URI segment.
 	 *
-	 * @access	private
 	 * @return	string
 	 */
 	protected function _parse_cli_args()
 	{
 		$args = array_slice($_SERVER['argv'], 1);
-
 		return $args ? '/' . implode('/', $args) : '';
 	}
 
@@ -256,27 +245,28 @@
 	/**
 	 * Filter segments for malicious characters
 	 *
-	 * @access	private
+	 * Called by CI_Router
+	 *
 	 * @param	string
 	 * @return	string
 	 */
-	function _filter_uri($str)
+	public function _filter_uri($str)
 	{
 		if ($str != '' && $this->config->item('permitted_uri_chars') != '' && $this->config->item('enable_query_strings') == FALSE)
 		{
 			// preg_quote() in PHP 5.3 escapes -, so the str_replace() and addition of - to preg_quote() is to maintain backwards
 			// compatibility as many are unaware of how characters in the permitted_uri_chars will be parsed as a regex pattern
-			if ( ! preg_match("|^[".str_replace(array('\\-', '\-'), '-', preg_quote($this->config->item('permitted_uri_chars'), '-'))."]+$|i", $str))
+			if ( ! preg_match('|^['.str_replace(array('\\-', '\-'), '-', preg_quote($this->config->item('permitted_uri_chars'), '-')).']+$|i', $str))
 			{
 				show_error('The URI you submitted has disallowed characters.', 400);
 			}
 		}
 
-		// Convert programatic characters to entities
-		$bad	= array('$',		'(',		')',		'%28',		'%29');
-		$good	= array('&#36;',	'&#40;',	'&#41;',	'&#40;',	'&#41;');
-
-		return str_replace($bad, $good, $str);
+		// Convert programatic characters to entities and return
+		return str_replace(
+					array('$',     '(',     ')',     '%28',   '%29'), // Bad
+					array('&#36;', '&#40;', '&#41;', '&#40;', '&#41;'), // Good
+					$str);
 	}
 
 	// --------------------------------------------------------------------
@@ -284,14 +274,15 @@
 	/**
 	 * Remove the suffix from the URL if needed
 	 *
-	 * @access	private
+	 * Called by CI_Router
+	 *
 	 * @return	void
 	 */
-	function _remove_url_suffix()
+	public function _remove_url_suffix()
 	{
-		if  ($this->config->item('url_suffix') != "")
+		if  ($this->config->item('url_suffix') != '')
 		{
-			$this->uri_string = preg_replace("|".preg_quote($this->config->item('url_suffix'))."$|", "", $this->uri_string);
+			$this->uri_string = preg_replace('|'.preg_quote($this->config->item('url_suffix')).'$|', '', $this->uri_string);
 		}
 	}
 
@@ -301,12 +292,13 @@
 	 * Explode the URI Segments. The individual segments will
 	 * be stored in the $this->segments array.
 	 *
-	 * @access	private
+	 * Called by CI_Router
+	 *
 	 * @return	void
 	 */
-	function _explode_segments()
+	public function _explode_segments()
 	{
-		foreach (explode("/", preg_replace("|/*(.+?)/*$|", "\\1", $this->uri_string)) as $val)
+		foreach (explode('/', preg_replace('|/*(.+?)/*$|', '\\1', $this->uri_string)) as $val)
 		{
 			// Filter segments for security
 			$val = trim($this->_filter_uri($val));
@@ -323,14 +315,15 @@
 	 * Re-index Segments
 	 *
 	 * This function re-indexes the $this->segment array so that it
-	 * starts at 1 rather than 0.  Doing so makes it simpler to
+	 * starts at 1 rather than 0. Doing so makes it simpler to
 	 * use functions like $this->uri->segment(n) since there is
 	 * a 1:1 relationship between the segment array and the actual segments.
 	 *
-	 * @access	private
+	 * Called by CI_Router
+	 *
 	 * @return	void
 	 */
-	function _reindex_segments()
+	public function _reindex_segments()
 	{
 		array_unshift($this->segments, NULL);
 		array_unshift($this->rsegments, NULL);
@@ -345,12 +338,11 @@
 	 *
 	 * This function returns the URI segment based on the number provided.
 	 *
-	 * @access	public
 	 * @param	integer
 	 * @param	bool
 	 * @return	string
 	 */
-	function segment($n, $no_result = FALSE)
+	public function segment($n, $no_result = FALSE)
 	{
 		return ( ! isset($this->segments[$n])) ? $no_result : $this->segments[$n];
 	}
@@ -364,12 +356,11 @@
 	 * based on the number provided.  If there is no routing this function returns the
 	 * same result as $this->segment()
 	 *
-	 * @access	public
 	 * @param	integer
 	 * @param	bool
 	 * @return	string
 	 */
-	function rsegment($n, $no_result = FALSE)
+	public function rsegment($n, $no_result = FALSE)
 	{
 		return ( ! isset($this->rsegments[$n])) ? $no_result : $this->rsegments[$n];
 	}
@@ -392,25 +383,22 @@
 	 *			gender => male
 	 *		 )
 	 *
-	 * @access	public
 	 * @param	integer	the starting segment number
 	 * @param	array	an array of default values
 	 * @return	array
 	 */
-	function uri_to_assoc($n = 3, $default = array())
+	public function uri_to_assoc($n = 3, $default = array())
 	{
 		return $this->_uri_to_assoc($n, $default, 'segment');
 	}
 	/**
 	 * Identical to above only it uses the re-routed segment array
 	 *
-	 * @access 	public
 	 * @param 	integer	the starting segment number
 	 * @param 	array	an array of default values
 	 * @return 	array
-	 *
 	 */
-	function ruri_to_assoc($n = 3, $default = array())
+	public function ruri_to_assoc($n = 3, $default = array())
 	{
 		return $this->_uri_to_assoc($n, $default, 'rsegment');
 	}
@@ -420,25 +408,13 @@
 	/**
 	 * Generate a key value pair from the URI string or Re-routed URI string
 	 *
-	 * @access	private
 	 * @param	integer	the starting segment number
 	 * @param	array	an array of default values
 	 * @param	string	which array we should use
 	 * @return	array
 	 */
-	function _uri_to_assoc($n = 3, $default = array(), $which = 'segment')
+	protected function _uri_to_assoc($n = 3, $default = array(), $which = 'segment')
 	{
-		if ($which == 'segment')
-		{
-			$total_segments = 'total_segments';
-			$segment_array = 'segment_array';
-		}
-		else
-		{
-			$total_segments = 'total_rsegments';
-			$segment_array = 'rsegment_array';
-		}
-
 		if ( ! is_numeric($n))
 		{
 			return $default;
@@ -449,23 +425,30 @@
 			return $this->keyval[$n];
 		}
 
+		if ($which === 'segment')
+		{
+			$total_segments = 'total_segments';
+			$segment_array = 'segment_array';
+		}
+		else
+		{
+			$total_segments = 'total_rsegments';
+			$segment_array = 'rsegment_array';
+		}
+
 		if ($this->$total_segments() < $n)
 		{
-			if (count($default) == 0)
+			if (count($default) === 0)
 			{
 				return array();
 			}
 
-			$retval = array();
-			foreach ($default as $val)
-			{
-				$retval[$val] = FALSE;
-			}
-			return $retval;
+			return function_exists('array_fill_keys')
+				? array_fill_keys($default, FALSE)
+				: array_combine($default, array_fill(0, count($default), FALSE));
 		}
 
 		$segments = array_slice($this->$segment_array(), ($n - 1));
-
 		$i = 0;
 		$lastval = '';
 		$retval  = array();
@@ -506,11 +489,10 @@
 	 * Generate a URI string from an associative array
 	 *
 	 *
-	 * @access	public
 	 * @param	array	an associative array of key/values
 	 * @return	array
 	 */
-	function assoc_to_uri($array)
+	public function assoc_to_uri($array)
 	{
 		$temp = array();
 		foreach ((array)$array as $key => $val)
@@ -527,12 +509,11 @@
 	/**
 	 * Fetch a URI Segment and add a trailing slash
 	 *
-	 * @access	public
 	 * @param	integer
 	 * @param	string
 	 * @return	string
 	 */
-	function slash_segment($n, $where = 'trailing')
+	public function slash_segment($n, $where = 'trailing')
 	{
 		return $this->_slash_segment($n, $where, 'segment');
 	}
@@ -542,12 +523,11 @@
 	/**
 	 * Fetch a URI Segment and add a trailing slash
 	 *
-	 * @access	public
 	 * @param	integer
 	 * @param	string
 	 * @return	string
 	 */
-	function slash_rsegment($n, $where = 'trailing')
+	public function slash_rsegment($n, $where = 'trailing')
 	{
 		return $this->_slash_segment($n, $where, 'rsegment');
 	}
@@ -557,22 +537,20 @@
 	/**
 	 * Fetch a URI Segment and add a trailing slash - helper function
 	 *
-	 * @access	private
 	 * @param	integer
 	 * @param	string
 	 * @param	string
 	 * @return	string
 	 */
-	function _slash_segment($n, $where = 'trailing', $which = 'segment')
+	protected function _slash_segment($n, $where = 'trailing', $which = 'segment')
 	{
-		$leading	= '/';
-		$trailing	= '/';
+		$leading = $trailing = '/';
 
-		if ($where == 'trailing')
+		if ($where === 'trailing')
 		{
 			$leading	= '';
 		}
-		elseif ($where == 'leading')
+		elseif ($where === 'leading')
 		{
 			$trailing	= '';
 		}
@@ -585,10 +563,9 @@
 	/**
 	 * Segment Array
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function segment_array()
+	public function segment_array()
 	{
 		return $this->segments;
 	}
@@ -598,10 +575,9 @@
 	/**
 	 * Routed Segment Array
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function rsegment_array()
+	public function rsegment_array()
 	{
 		return $this->rsegments;
 	}
@@ -611,10 +587,9 @@
 	/**
 	 * Total number of segments
 	 *
-	 * @access	public
 	 * @return	integer
 	 */
-	function total_segments()
+	public function total_segments()
 	{
 		return count($this->segments);
 	}
@@ -624,10 +599,9 @@
 	/**
 	 * Total number of routed segments
 	 *
-	 * @access	public
 	 * @return	integer
 	 */
-	function total_rsegments()
+	public function total_rsegments()
 	{
 		return count($this->rsegments);
 	}
@@ -637,10 +611,9 @@
 	/**
 	 * Fetch the entire URI string
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function uri_string()
+	public function uri_string()
 	{
 		return $this->uri_string;
 	}
@@ -651,16 +624,14 @@
 	/**
 	 * Fetch the entire Re-routed URI string
 	 *
-	 * @access	public
 	 * @return	string
 	 */
-	function ruri_string()
+	public function ruri_string()
 	{
 		return '/'.implode('/', $this->rsegment_array());
 	}
 
 }
-// END URI Class
 
 /* End of file URI.php */
-/* Location: ./system/core/URI.php */
\ No newline at end of file
+/* Location: ./system/core/URI.php */
diff --git a/system/core/Utf8.php b/system/core/Utf8.php
index 40a7ac4..0e180d3 100644
--- a/system/core/Utf8.php
+++ b/system/core/Utf8.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.1.6 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -47,20 +47,19 @@
 	 */
 	public function __construct()
 	{
-		log_message('debug', "Utf8 Class Initialized");
+		log_message('debug', 'Utf8 Class Initialized');
 
 		global $CFG;
 
 		if (
 			@preg_match('/./u', 'é') === 1		// PCRE must support UTF-8
 			&& function_exists('iconv')			// iconv must be installed
-			&& ini_get('mbstring.func_overload') !== 1	// Multibyte string function overloading cannot be enabled
-			&& $CFG->item('charset') == 'UTF-8'			// Application charset must be UTF-8
+			&& @ini_get('mbstring.func_overload') != 1	// Multibyte string function overloading cannot be enabled
+			&& $CFG->item('charset') === 'UTF-8'		// Application charset must be UTF-8
 			)
 		{
-			log_message('debug', "UTF-8 Support Enabled");
-
 			define('UTF8_ENABLED', TRUE);
+			log_message('debug', 'UTF-8 Support Enabled');
 
 			// set internal encoding for multibyte string functions if necessary
 			// and set a flag so we don't have to repeatedly use extension_loaded()
@@ -77,8 +76,8 @@
 		}
 		else
 		{
-			log_message('debug', "UTF-8 Support Disabled");
 			define('UTF8_ENABLED', FALSE);
+			log_message('debug', 'UTF-8 Support Disabled');
 		}
 	}
 
@@ -134,18 +133,14 @@
 	{
 		if (function_exists('iconv'))
 		{
-			$str = @iconv($encoding, 'UTF-8', $str);
+			return @iconv($encoding, 'UTF-8', $str);
 		}
 		elseif (function_exists('mb_convert_encoding'))
 		{
-			$str = @mb_convert_encoding($str, 'UTF-8', $encoding);
-		}
-		else
-		{
-			return FALSE;
+			return @mb_convert_encoding($str, 'UTF-8', $encoding);
 		}
 
-		return $str;
+		return FALSE;
 	}
 
 	// --------------------------------------------------------------------
@@ -163,10 +158,7 @@
 		return (preg_match('/[^\x00-\x7F]/S', $str) === 0);
 	}
 
-	// --------------------------------------------------------------------
-
 }
-// End Utf8 Class
 
 /* End of file Utf8.php */
-/* Location: ./system/core/Utf8.php */
\ No newline at end of file
+/* Location: ./system/core/Utf8.php */
diff --git a/user_guide_src/source/changelog.rst b/user_guide_src/source/changelog.rst
index 763f58b..7e7be06 100644
--- a/user_guide_src/source/changelog.rst
+++ b/user_guide_src/source/changelog.rst
@@ -31,6 +31,8 @@
    -  Added application/xml for xml and application/xml, text/xsl for xsl in mimes.php.
    -  Changed logger to only chmod when file is first created.
    -  Removed previously deprecated SHA1 Library.
+   -  Removed previously deprecated use of ``$autoload['core']`` in application/config/autoload.php.
+      Only entries in ``$autoload['libraries']`` are auto-loaded now.
 
 -  Helpers
 
@@ -66,10 +68,9 @@
 
 -  Core
 
-   -  Changed private functions in CI_URI to protected so MY_URI can
-      override them.
+   -  Changed private functions in CI_URI to protected so MY_URI can override them.
    -  Removed CI_CORE boolean constant from CodeIgniter.php (no longer Reactor and Core versions).
-   -  Added method get_vars() to CI_Loader to retrieve all variables loaded with $this->load->vars()
+   -  Added method get_vars() to CI_Loader to retrieve all variables loaded with $this->load->vars().
 
 Bug fixes for 3.0
 ------------------
diff --git a/user_guide_src/source/installation/upgrade_300.rst b/user_guide_src/source/installation/upgrade_300.rst
index 960485a..4c594ab 100644
--- a/user_guide_src/source/installation/upgrade_300.rst
+++ b/user_guide_src/source/installation/upgrade_300.rst
@@ -15,6 +15,9 @@
 your index.php file. If any modifications were made to your index.php
 they will need to be made fresh in this new one.
 
+.. note:: If you have any custom developed files in these folders please
+	make copies of them first.
+
 Step 2: Change References to the SHA Library
 ============================================
 
@@ -23,6 +26,8 @@
 
 Additionally, the `sha1()` method in the :doc:`Encryption Library <../libraries/encryption>` has been removed.
 
+Step 3: Remove $autoload['core'] from your config/autoload.php
+==============================================================
 
-.. note:: If you have any custom developed files in these folders please
-	make copies of them first.
+Use of the `$autoload['core']` config array has been deprecated as of CodeIgniter 1.4.1 and is now removed.
+Move any entries that you might have listed there to `$autoload['libraries']` instead.
